package com.qire.common.collect;

import java.util.Arrays;

public class ArrayUtil {

    /**
     * 判断数组是否为空
     * @param array 待检查数组
     * @return true 为 null 或 长度为0 ,否则false
     */
    public static <T> boolean isEmpty(T[] array) {
        return array == null || array.length == 0;
    }

    /**
     * 判断数组是否不为空
     * @param array 判定对象
     * @return 容器为null或者没有数据为false,否则true
     */
    public static <T> boolean notEmpty(T[] array) {
        return !isEmpty(array);
    }

    /**
     * 索引是否在目标容器范围内
     * @param array 判断对象
     * @param index 指定索引
     * @return 如果容器为 null 或 index 不在容器可取范围内为 false，否则为 true
     */
    public static boolean range(Object[] array, int index) {
        if(array == null) {
            return false;
        }
        return index >= 0 && index < array.length;
    }

    /**
     * 获取数组大小，如果数组为 null 则返回0
     * @param array 目标数组
     * @param <T> 数组类型
     * @return 数组为null 则返回 0  否则返回数组 {@code array.length}
     */
    public static <T> int size(T[] array) {
        return array == null ? 0 : array.length;
    }

    /**
     * 获得指定对象在数组中的索引位置，从0开始
     * @param array 数组
     * @param object 指定对象
     * @return 返回所在位置索引，如果数组不包括对象或数组为 {@code null} 则返回 -1
     */
    public static int indexOf(Object[] array, Object object) {
        if(array == null) {
            return -1;
        }
        for(int index = 0; index < array.length; index++) {
            if(array[index].equals(object)) {
                return index;
            }
        }
        return -1;
    }

    /**
     * 使用源数组 {@code srcArray} 置换目标数组 {@code dstArray}，如果源数组和目标数组中有一个为空则返回 false，否则置换完成返回true；
     * 置换的规则为以目标数组测长度为大小循环取出源数组对应索引元素放置到目标数组对应下标中。如果超出源数组长度的部分不会替换。只替换源数组和目标数组下标交集。
     * @param srcArray
     * @param dstArray
     * @param <T>
     * @return
     */
    public static <T> boolean replace(T[] srcArray, T[] dstArray) {
        if(isEmpty(dstArray) || isEmpty(srcArray)) {
            return false;
        }

        for(int index = 0; index < dstArray.length; index++) {
            if(range(srcArray, index)) {
                dstArray[index] = srcArray[index];
            }
        }
        return true;
    }

    /**
     * 填充数组
     * @param array 目标数组
     * @param t 填充数据
     * @param <T> 数据类型
     */
    public static <T> void fill(T[] array, T t) {
        fill(array, t, 0, Integer.MAX_VALUE);
    }

    /**
     * 填充数组，从begin开始到end范围
     * @param array 数组
     * @param t 数据
     * @param begin 起始点
     * @param end 结束点
     * @param <T> 数据类型
     */
    public static <T> void fill(T[] array, T t, int begin, int end) {
        if(notEmpty(array)) {
            end = Math.min(end, array.length);
            for(int i = begin; i < end; i++) {
                array[i] = t;
            }
        }
    }

    public static <T> T[] copy(T[] array) {
        return Arrays.copyOf(array, array.length);
    }
}
